namespace Model
{
    using System;
    using System.Data.Entity;
    using System.ComponentModel.DataAnnotations.Schema;
    using System.Linq;

    public partial class Model1 : DbContext
    {
        public Model1()
            : base("name=Model1")
        {
        }

        public virtual DbSet<Bound> Bound { get; set; }
        public virtual DbSet<Deadline> Deadline { get; set; }
        public virtual DbSet<Dynamics> Dynamics { get; set; }
        public virtual DbSet<Earnings> Earnings { get; set; }
        public virtual DbSet<Email> Email { get; set; }
        public virtual DbSet<Experience> Experience { get; set; }
        public virtual DbSet<Invest> Invest { get; set; }
        public virtual DbSet<Logins> Logins { get; set; }
        public virtual DbSet<Mark> Mark { get; set; }
        public virtual DbSet<Nav> Nav { get; set; }
        public virtual DbSet<Navigation> Navigation { get; set; }
        public virtual DbSet<Notice> Notice { get; set; }
        public virtual DbSet<Partners> Partners { get; set; }
        public virtual DbSet<Pledge> Pledge { get; set; }
        public virtual DbSet<PledgeType> PledgeType { get; set; }
        public virtual DbSet<PowerGroup> PowerGroup { get; set; }
        public virtual DbSet<Powers> Powers { get; set; }
        public virtual DbSet<Project> Project { get; set; }
        public virtual DbSet<ProjectType> ProjectType { get; set; }
        public virtual DbSet<Role_Power_Group> Role_Power_Group { get; set; }
        public virtual DbSet<Roles> Roles { get; set; }
        public virtual DbSet<signs> signs { get; set; }
        public virtual DbSet<State> State { get; set; }
        public virtual DbSet<Status> Status { get; set; }
        public virtual DbSet<sysdiagrams> sysdiagrams { get; set; }
        public virtual DbSet<UserInfo> UserInfo { get; set; }

        protected override void OnModelCreating(DbModelBuilder modelBuilder)
        {
            modelBuilder.Entity<Bound>()
                .Property(e => e.BoundName)
                .IsUnicode(false);

            modelBuilder.Entity<Bound>()
                .Property(e => e.BoundContent)
                .IsUnicode(false);

            modelBuilder.Entity<Bound>()
                .Property(e => e.BoundPhone)
                .IsUnicode(false);

            modelBuilder.Entity<Bound>()
                .Property(e => e.BoundCode)
                .IsUnicode(false);

            modelBuilder.Entity<Deadline>()
                .Property(e => e.DeadlineName)
                .IsUnicode(false);

            modelBuilder.Entity<Dynamics>()
                .Property(e => e.DynamicName)
                .IsUnicode(false);

            modelBuilder.Entity<Dynamics>()
                .Property(e => e.DynamicContent)
                .IsUnicode(false);

            modelBuilder.Entity<Dynamics>()
                .Property(e => e.Issuer)
                .IsUnicode(false);

            modelBuilder.Entity<Earnings>()
                .Property(e => e.EarningsScope)
                .IsUnicode(false);

            modelBuilder.Entity<Email>()
                .Property(e => e.EmailName)
                .IsUnicode(false);

            modelBuilder.Entity<Email>()
                .Property(e => e.EmailContent)
                .IsUnicode(false);

            modelBuilder.Entity<Email>()
                .Property(e => e.Email1)
                .IsUnicode(false);

            modelBuilder.Entity<Email>()
                .Property(e => e.EmailCode)
                .IsUnicode(false);

            modelBuilder.Entity<Experience>()
                .Property(e => e.ExperienceName)
                .IsUnicode(false);

            modelBuilder.Entity<Experience>()
                .Property(e => e.EarningsWay)
                .IsUnicode(false);

            modelBuilder.Entity<Experience>()
                .Property(e => e.Tyield)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Experience>()
                .Property(e => e.EarningsDeadline)
                .IsUnicode(false);

            modelBuilder.Entity<Experience>()
                .Property(e => e.Institution)
                .IsUnicode(false);

            modelBuilder.Entity<Experience>()
                .Property(e => e.ExperienceMoney)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Experience>()
                .Property(e => e.ExpericecePlan)
                .IsUnicode(false);

            modelBuilder.Entity<Invest>()
                .Property(e => e.Invester)
                .IsUnicode(false);

            modelBuilder.Entity<Invest>()
                .Property(e => e.InvestMoney)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Invest>()
                .Property(e => e.InvestGain)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Invest>()
                .Property(e => e.InvestRaterate)
                .IsUnicode(false);

            modelBuilder.Entity<Logins>()
                .Property(e => e.UserName)
                .IsUnicode(false);

            modelBuilder.Entity<Logins>()
                .Property(e => e.UserPwd)
                .IsUnicode(false);

            modelBuilder.Entity<Mark>()
                .Property(e => e.MarkTitle)
                .IsUnicode(false);

            modelBuilder.Entity<Mark>()
                .Property(e => e.MarkPerson)
                .IsUnicode(false);

            modelBuilder.Entity<Mark>()
                .Property(e => e.MarkContent)
                .IsUnicode(false);

            modelBuilder.Entity<Nav>()
                .Property(e => e.NavName)
                .IsUnicode(false);

            modelBuilder.Entity<Navigation>()
                .Property(e => e.NavigationName)
                .IsUnicode(false);

            modelBuilder.Entity<Notice>()
                .Property(e => e.NoticeName)
                .IsUnicode(false);

            modelBuilder.Entity<Notice>()
                .Property(e => e.NoticeContent)
                .IsUnicode(false);

            modelBuilder.Entity<Notice>()
                .Property(e => e.NoticePerson)
                .IsUnicode(false);

            modelBuilder.Entity<Partners>()
                .Property(e => e.PartnerUrl)
                .IsUnicode(false);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.Pledgemoney)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgePhone)
                .IsUnicode(false);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgeWay)
                .IsUnicode(false);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgeValue)
                .HasPrecision(10, 2);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgeUse)
                .IsUnicode(false);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgeScribe)
                .IsUnicode(false);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgeCode)
                .IsUnicode(false);

            modelBuilder.Entity<Pledge>()
                .Property(e => e.PledgePerson)
                .IsUnicode(false);

            modelBuilder.Entity<PledgeType>()
                .Property(e => e.PledgeTypeName)
                .IsUnicode(false);

            modelBuilder.Entity<PowerGroup>()
                .Property(e => e.PowerGroupName)
                .IsUnicode(false);

            modelBuilder.Entity<Powers>()
                .Property(e => e.PowerName)
                .IsUnicode(false);

            modelBuilder.Entity<Project>()
                .Property(e => e.ProjectName)
                .IsUnicode(false);

            modelBuilder.Entity<ProjectType>()
                .Property(e => e.ProjectTypeName)
                .IsUnicode(false);

            modelBuilder.Entity<Roles>()
                .Property(e => e.RoleName)
                .IsUnicode(false);

            modelBuilder.Entity<signs>()
                .Property(e => e.SignName)
                .IsUnicode(false);

            modelBuilder.Entity<signs>()
                .Property(e => e.Tyield)
                .HasPrecision(10, 2);

            modelBuilder.Entity<signs>()
                .Property(e => e.SendMoney)
                .HasPrecision(10, 2);

            modelBuilder.Entity<signs>()
                .Property(e => e.AmountMoney)
                .HasPrecision(10, 2);

            modelBuilder.Entity<signs>()
                .Property(e => e.ChdMoney)
                .HasPrecision(10, 2);

            modelBuilder.Entity<signs>()
                .Property(e => e.Image)
                .IsUnicode(false);

            modelBuilder.Entity<State>()
                .Property(e => e.StateName)
                .IsUnicode(false);

            modelBuilder.Entity<State>()
                .HasMany(e => e.Experience)
                .WithOptional(e => e.State)
                .HasForeignKey(e => e.SateId);

            modelBuilder.Entity<State>()
                .HasMany(e => e.signs)
                .WithOptional(e => e.State)
                .HasForeignKey(e => e.SateId);

            modelBuilder.Entity<Status>()
                .Property(e => e.StatusName)
                .IsUnicode(false);

            modelBuilder.Entity<Status>()
                .Property(e => e.StatusContent)
                .IsUnicode(false);

            modelBuilder.Entity<Status>()
                .Property(e => e.StatusTel)
                .IsUnicode(false);

            modelBuilder.Entity<Status>()
                .Property(e => e.StatusCode)
                .IsUnicode(false);

            modelBuilder.Entity<UserInfo>()
                .Property(e => e.UserName)
                .IsUnicode(false);

            modelBuilder.Entity<UserInfo>()
                .Property(e => e.UserPwd)
                .IsUnicode(false);

            modelBuilder.Entity<UserInfo>()
                .Property(e => e.UserTel)
                .IsUnicode(false);

            modelBuilder.Entity<UserInfo>()
                .Property(e => e.UserNum)
                .IsUnicode(false);

            modelBuilder.Entity<UserInfo>()
                .Property(e => e.UserInvite)
                .IsUnicode(false);
        }
    }
}
